﻿using System;
using System.Collections.Generic;

using System.Text;

namespace Rance.Battle
{
    class 角色
    {
        public 角色()
        {
            ID = Guid.NewGuid();
        }

        #region 基础属性

        public Guid ID { get; set; }

        public string Name { get; set; }
        public bool 特殊人物 { get; set; }

        public 兵种 兵种 { get; set; }

        public int 临时攻 { get; set; }
        public int 临时防 { get; set; }
        public int 临时智 { get; set; }
        public int 临时速 { get; set; }
        public int 攻 { get; set; }
        public int 防 { get; set; }
        public int 智 { get; set; }
        public int 速 { get; set; }

        public int 最大兵力 { get; set; }
        public int 兵力 { get; set; }

        public int 顺序值 { get; set; }
        public int 行动次序 { get; set; }

        public int 最大行动点 { get; set; }
        public int 行动点 { get; set; }

        public bool 是否败退 { get; set; }
        public bool 是否准备 { get; set; }
        public bool 是否完结 { get { return 行动点 == 0; } }

        public int 救援率 { get; set; }
        public int 救援兵力比率 { get; set; }

        public string 装备 { get; set; }

        public string 战斗开始被动技能选择 { get; set; }

        public string AI { get; set; }

        public bool 是否队伍1 { get; set; }

        private 赋予 _攻击赋予;
        public 赋予 攻击赋予
        {
            get 
            {
                if (_攻击赋予 != null && _攻击赋予.Level < 0)
                    return null;
                else
                    return _攻击赋予; 
            }
        }

        public 赋予 攻击诅咒
        {
            get
            {
                if (_攻击赋予 != null && _攻击赋予.Level > 0)
                    return null;
                else
                    return _攻击赋予;
            }
        }

        public bool Set攻击赋予(赋予 赋予)
        {
            if (_攻击赋予 == null)
            {
                _攻击赋予 = 赋予;
                return true;
            }
            else if (_攻击赋予.Level > 0 && 赋予.Level > 0)
            {
                if (赋予.Level >= _攻击赋予.Level)
                {
                    _攻击赋予 = 赋予;
                    return true;
                }
            }
            else 
            {
                _攻击赋予 = 赋予;
                return true;
            }
            return false;
        }

        public bool Set攻击诅咒(赋予 诅咒)
        {
            if (_攻击赋予 == null)
            {
                _攻击赋予 = 诅咒;
                return true;
            }
            else if (_攻击赋予.Level < 0 && 诅咒.Level < 0)
            {
                if (诅咒.Level <= _攻击赋予.Level)
                {
                    _攻击赋予 = 诅咒;
                    return true;
                }
            }
            else
            {
                _攻击赋予 = 诅咒;
                return true;
            }
            return false;
        }

        public bool Clear攻击赋予()
        {
            if (_攻击赋予 != null && _攻击赋予.Level > 0) 
            {
                _攻击赋予 = null;
                return true;
            }

            return false;
        }

        private 赋予 _防御赋予;
        public 赋予 防御赋予
        {
            get
            {
                if (_防御赋予 != null && _防御赋予.Level < 0)
                    return null;
                else
                    return _防御赋予;
            }
        }

        public 赋予 防御诅咒
        {
            get
            {
                if (_防御赋予 != null && _防御赋予.Level > 0)
                    return null;
                else
                    return _防御赋予;
            }
        }

        public bool Set防御赋予(赋予 赋予)
        {
            if (_防御赋予 == null)
            {
                _防御赋予 = 赋予;
                return true;
            }
            else if (_防御赋予.Level > 0 && 赋予.Level > 0)
            {
                if (赋予.Level >= _防御赋予.Level)
                {
                    _防御赋予 = 赋予;
                    return true;
                }
            }
            else
            {
                _防御赋予 = 赋予;
                return true;
            }
            return false;
        }

        public bool Set防御诅咒(赋予 诅咒)
        {
            if (_防御赋予 == null)
            {
                _防御赋予 = 诅咒;
                return true;
            }
            else if (_防御赋予.Level < 0 && 诅咒.Level < 0)
            {
                if (诅咒.Level <= _防御赋予.Level)
                {
                    _防御赋予 = 诅咒;
                    return true;
                }
            }
            else
            {
                _防御赋予 = 诅咒;
                return true;
            }
            return false;
        }

        public bool Clear防御赋予()
        {
            if (_防御赋予 != null && _防御赋予.Level > 0)
            {
                _防御赋予 = null;
                return true;
            }

            return false;
        }

        private 赋予 _速度赋予;
        public 赋予 速度赋予
        {
            get
            {
                if (_速度赋予 != null && _速度赋予.Level < 0)
                    return null;
                else
                    return _速度赋予;
            }
        }

        public 赋予 速度诅咒
        {
            get
            {
                if (_速度赋予 != null && _速度赋予.Level > 0)
                    return null;
                else
                    return _速度赋予;
            }
        }

        public bool Set速度赋予(赋予 赋予)
        {
            if (_速度赋予 == null)
            {
                _速度赋予 = 赋予;
                return true;
            }
            else if (_速度赋予.Level > 0 && 赋予.Level > 0)
            {
                if (赋予.Level >= _速度赋予.Level)
                {
                    _速度赋予 = 赋予;
                    return true;
                }
            }
            else
            {
                _速度赋予 = 赋予;
                return true;
            }
            return false;
        }

        public bool Set速度诅咒(赋予 诅咒)
        {
            if (_速度赋予 == null)
            {
                _速度赋予 = 诅咒;
                return true;
            }
            else if (_速度赋予.Level < 0 && 诅咒.Level < 0)
            {
                if (诅咒.Level <= _速度赋予.Level)
                {
                    _速度赋予 = 诅咒;
                    return true;
                }
            }
            else
            {
                _速度赋予 = 诅咒;
                return true;
            }
            return false;
        }

        public bool Clear速度赋予()
        {
            if (_速度赋予 != null && _速度赋予.Level > 0)
            {
                _速度赋予 = null;
                return true;
            }

            return false;
        }

        private 赋予 _智力赋予;
        public 赋予 智力赋予
        {
            get
            {
                if (_智力赋予 != null && _智力赋予.Level < 0)
                    return null;
                else
                    return _智力赋予;
            }
        }

        public 赋予 智力诅咒
        {
            get
            {
                if (_智力赋予 != null && _智力赋予.Level > 0)
                    return null;
                else
                    return _智力赋予;
            }
        }

        public bool Set智力赋予(赋予 赋予)
        {
            if (_智力赋予 == null)
            {
                _智力赋予 = 赋予;
                return true;
            }
            else if (_智力赋予.Level > 0 && 赋予.Level > 0)
            {
                if (赋予.Level >= _智力赋予.Level)
                {
                    _智力赋予 = 赋予;
                    return true;
                }
            }
            else
            {
                _智力赋予 = 赋予;
                return true;
            }
            return false;
        }

        public bool Set智力诅咒(赋予 诅咒)
        {
            if (_智力赋予 == null)
            {
                _智力赋予 = 诅咒;
                return true;
            }
            else if (_智力赋予.Level < 0 && 诅咒.Level < 0)
            {
                if (诅咒.Level <= _智力赋予.Level)
                {
                    _智力赋予 = 诅咒;
                    return true;
                }
            }
            else
            {
                _智力赋予 = 诅咒;
                return true;
            }
            return false;
        }

        public bool Clear智力赋予()
        {
            if (_智力赋予 != null && _智力赋予.Level > 0)
            {
                _智力赋予 = null;
                return true;
            }

            return false;
        }

        public 被动技能 被动技能 { get; set; }
        public 主动技能 基础攻击技能 { get; set; }
        public 主动技能 技能1 { get; set; }
        public 主动技能 技能2 { get; set; }
        public 技能 隐藏技能 { get; set; }
        public 主动技能 待机 { get; set; }

        public int 排 { get; set; }
        public int 列 { get; set; }

        public int 守护率 { get; set; }
        public int 全体守护率 { get; set; }

        public 主动技能 准备技能 { get; set; }

        public bool 护盾 { get; set; }

        public List<效果> 效果List = new List<效果>();

        public void Add(效果 效果)
        {
            foreach (var item in 效果List.ToArray())
            {
                if (item.GetType() == 效果.GetType())
                    return;

                if (item.GetType().IsSubclassOf(效果.GetType()))
                    return;

                if (效果.GetType().IsSubclassOf(item.GetType()))
                    效果List.Remove(item);
            }

            效果List.Add(效果);
        }

        public 效果 Find效果(Type 效果Type)
        {
            foreach (var 效果 in 效果List)
            {
                if (效果.GetType() == 效果Type)
                    return 效果;
            }

            return null;
        }

        public int 物理减伤 { get; set; }
        public int 物理额外伤害 { get; set; }
        public bool 物理穿透 { get; set; }
        public int 法术减伤 { get; set; }

        public int 本回合物理减伤 { get; set; }
        public int 本回合物理额外伤害 { get; set; }
        public bool 本回合物理穿透 { get; set; }
        public int 本回合法术减伤 { get; set; }

        public int 道具物理吸血 { get; set; }
        public int 技能物理吸血 { get; set; }

        public int 物理吸血 { get { return 技能物理吸血 + 道具物理吸血; } }

        public int 道具自动恢复 { get; set; }
        public int 技能自动恢复 { get; set; }

        public int 自动恢复 { get { return 道具自动恢复 + 技能自动恢复; } }

        #endregion

        #region 计算属性

        public int 实际兵力
        {
            get
            {
                int i1, i2, i3;
                if (兵力 >= 500)
                {
                    i1 = 500;

                    if (兵力 >= 1500)
                    {
                        i2 = 500;
                        i3 = (兵力 - 1500) / 4;
                    }
                    else
                    {
                        i2 = (兵力 - 500) / 2;
                        i3 = 0;
                    }
                }
                else
                {
                    i1 = 兵力;
                    i2 = 0;
                    i3 = 0;
                }

                int i4 = 临时攻 >= 3 ? (临时攻 - 3) * 60 : 60;

                return Convert.ToInt32((i1 + i2 + i3) * 0.9m) + i4;

            }
        }



        public decimal 实际攻
        {
            get
            {
                if (攻击赋予 == null)
                    return 临时攻;
                else
                {
                    var temp = 临时攻 * 常量.赋予效果系数[攻击赋予.Level] / 100m;
                    if (temp > 0 && temp < 常量.最小赋予影响系数[攻击赋予.Level])
                        temp = 常量.最小赋予影响系数[攻击赋予.Level];
                    else if (temp < 0 && temp > 常量.最小赋予影响系数[攻击赋予.Level])
                        temp = 常量.最小赋予影响系数[攻击赋予.Level];

                    return 临时攻 + temp;
                }
            }
        }

        public decimal 实际防
        {
            get
            {
                if (防御赋予 == null)
                    return 临时防;
                else
                {
                    var temp = 临时防 * 常量.赋予效果系数[防御赋予.Level] / 100m;
                    if (temp > 0 && temp < 常量.最小赋予影响系数[防御赋予.Level])
                        temp = 常量.最小赋予影响系数[防御赋予.Level];
                    else if (temp < 0 && temp > 常量.最小赋予影响系数[防御赋予.Level])
                        temp = 常量.最小赋予影响系数[防御赋予.Level];

                    return 临时防 + temp;
                }
            }
        }

        public decimal 实际速
        {
            get
            {
                if (速度赋予 == null)
                    return 临时速;
                else
                {
                    var temp = 临时速 * 常量.赋予效果系数[速度赋予.Level] / 100m;
                    if (temp > 0 && temp < 常量.最小赋予影响系数[速度赋予.Level])
                        temp = 常量.最小赋予影响系数[速度赋予.Level];
                    else if (temp < 0 && temp > 常量.最小赋予影响系数[速度赋予.Level])
                        temp = 常量.最小赋予影响系数[速度赋予.Level];

                    return 临时速 + temp;
                }
            }
        }

        public decimal 实际智
        {
            get
            {
                if (智力赋予 == null)
                    return 临时智;
                else
                {
                    var temp = 临时智 * 常量.赋予效果系数[智力赋予.Level] / 100m;
                    if (temp > 0 && temp < 常量.最小赋予影响系数[智力赋予.Level])
                        temp = 常量.最小赋予影响系数[智力赋予.Level];
                    else if (temp < 0 && temp > 常量.最小赋予影响系数[智力赋予.Level])
                        temp = 常量.最小赋予影响系数[智力赋予.Level];

                    return 临时智 + temp;
                }
            }
        }
        #endregion

        public override string ToString()
        {
            return Name + " " + 顺序值.ToString();
        }

        public void 败退()
        {
            是否败退 = true;
            是否准备 = false;
            守护率 = 0;
            全体守护率 = 0;
            救援率 = 0;
        }

        public int TempValue;
    }
}
